Fundamentos de Sistemas Operacionais

Fundamentos de Sistemas Operacionais

O que é um sistema operacional?

Os sistemas operacionais realizam duas funções essencialmente não relacionadas: (1) fornecer a programadores de aplicativos (e programas aplicativos, claro) um conjunto de recursos abstratos limpo em vez de recursos confusos de hardware, e (2) gerenciar esses recursos de hardware

O que é um sistema operacional?

Usando essa abstração, os programas podem criar, escrever, ler arquivos, sem ter que lidar com detalhes complexos de como o hardware funciona

O que é um sistema operacional?

O conceito de um sistema operacional como fundamentalmente fornecendo abstrações para programas aplicativos é uma visão top-down (abstração de cima para baixo). Uma visão alternativa, bottom-up (abstração de baixo para cima), sustenta que o sistema operacional está ali para gerenciar todas as partes de um sistema complexo.

O que é um sistema operacional?

O que é um sistema operacional?

1. Quando múltiplas saídas de impressão estão na fila para serem impressas em uma única impressora, uma decisão tem de ser tomada sobre qual deve ser impressa em seguida.

2. Em vez de os clientes se revezarem, cada um tem direito a uma parte do recurso. Por exemplo, a memória principal é normalmente dividida entre vários programas sendo executados, de modo que cada um pode ser residente ao mesmo tempo (por exemplo, a fim de se revezar usando a CPU).

Revisão sobre hardware de computadores

A CPU, memória e dispositivos de E/S estão todos conectados por um sistema de barramento (bus) e comunicam-se uns com os outros sobre ele.

Revisão sobre hardware de computadores

Processadores

O “cérebro” do computador é a CPU. O ciclo básico de toda CPU é buscar a primeira instrução da memória, decodificá-la para determinar o seu tipo e operandos, executá-la.

Revisão sobre hardware de computadores

Memória

Exemplo de utilização de cache

O zoológico dos sistemas operacionais

• Sistemas operacionais de computadores de grande porte, de alto desempenho e alta disponibilidade (mainframes)
• Sistemas operacionais de servidores
• Sistemas operacionais de computadores pessoais
• Sistemas operacionais de computadores portáteis
• Sistemas operacionais embarcados
• Sistemas operacionais de tempo real

Conceitos de sistemas operacionais

• Processos: [um processo é basicamente um programa em execução].marked e associado a cada processo está um espaço de endereçamento, uma lista de posições de mémoria que vai de 0 a algum máximo, onde o processo pode ler e escrever.
• Espaços de endereçamento: diz respeito ao gerenciamento e à proteção da memória principal do computador, quando se tem multiplos processos sendo executados.
• Arquivos: um sistema de arquivos é uma estrutura usada por um sistema operacional para organizar e gerenciar arquivos em um dispositivo de armazenamento. Chamadas do sistemas são necessárias para criar, remover, ler escrever arquivos. Existe o conceito de diretório como uma maneira de agrupar os arquivos

Conceitos de sistemas operacionais

• Entrada/Saída: o sistema operacional tem um subsistema de E/S para gerenciamento dos dispositivos.
• Proteção: o sistema operacional gerencia a segurança do sistema de maneira que os arquivos, por exemplo, sejam acessíveis somente por usuários autorizados.
• Interpretador de comandos (shell): é a principal interface entre um usuário e o sistema operacional.

Conceitos de sistemas operacionais

Memória virtual: A memória virtual proporciona a capacidade de executar programas maiores do que a memória física da máquina, rapidamente movendo pedaços entre a memória RAM e o disco.

Quando se instala o linux é possível definir o tamanho da partição do disco que será utilizado pela memória virtual (swap).

Chamadas de sistema

Já vimos que os sistemas operacionais apresentam duas funções: abstrações para os usuários e gerenciamento de recursos.

Chamadas de sistema

Chamadas de sistema

Chamadas de sistema

write.cpp

#include<unistd.h>

int main() 
{
    write(1, "Ola Mundo!", 10);
}

Chamadas de sistema

• Chamadas de sistema para gerenciamento de processos
• Chamadas de sistema para gerenciamento de arquivos
• Chamadas de sistema para gerenciamento de diretórios
• Chamadas de sistema diversas

Chamadas de sistema para gerenciamento de processos

Chamadas de sistema para gerenciamento de processos

fork

fork_exemplo.cpp

#include <stdio.h>
#include <unistd.h>

int main()
{
    // make two process which run same
    // program after this instruction
    pid = fork();
    if(pid < 0){
    perror("fork fail");
    _exit(1);
    }
    printf("Hello world!, process_id(pid) = %d \n", getpid());
    return 0;
}

Hello world!, process_id(pid) = 685 
Hello world!, process_id(pid) = 686

Chamadas de sistema para gerenciamento de processos

waitpid

waitpid_exemplo.cpp

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int i = 1;
int pid;
int waitpid_return;
int main ()
{   
    printf("process_id(pid) parent= %d\n", getpid());
    pid = fork();
    if (pid != 0)
    {   
      
      for (int i = 1; i < 5; i++) {
        waitpid_return = waitpid(pid, NULL, WNOHANG);
        printf("%d, process_id(pid) child = %d, waitpid = %d\n", i, pid, waitpid_return);
      }
    }
    else {
        waitpid_return = waitpid(pid, NULL, WNOHANG);
        printf("%d, process_id(pid) child = %d, waitpid = %d\n", i, pid, waitpid_return);}
        return 0;
    }

Chamadas de sistema para gerenciamento de processos

execve

#include <unistd.h>
#include <iostream>
#include <string>

std::string c = "/bin/ls";
std::string p = "-lh";
char *args[] = {c.data(), p.data()};
int main() {
  execve(args[0], args, NULL);
}

Chamadas de sistema para gerenciamento de diretórios

Chamadas de sistema para gerenciamento diversos

Monolítico

• Nesta estrutura, todo o sistema operacional é implementado como um único programa de grande porte.
• Todas as funcionalidades do sistema operacional, como gerenciamento de memória, gerenciamento de processos e sistemas de arquivos, residem no kernel.
• Exemplos incluem sistemas operacionais mais antigos, como MS-DOS e versões mais antigas do UNIX.

Microkernel

• Neste modelo, o kernel é mínimo e fornece apenas as funcionalidades básicas, como gerenciamento de memória, comunicação entre processos e escalonamento de CPU.
• Funcionalidades adicionais, como sistemas de arquivos e drivers de dispositivos, são implementadas como processos de usuário que se comunicam com o kernel.
• Exemplos incluem o MINIX e o Symbian.

Desse modo, um erro no driver de áudio fará que o som fique truncado ou pare, mas não derrubará o computador.

Híbrido

• Esta abordagem combina elementos do kernel monolítico e do microkernel.
• O kernel contém algumas funcionalidades essenciais, como gerenciamento de memória e escalonamento de processos, enquanto outras funcionalidades são implementadas como módulos do kernel ou como processos de usuário.
• Exemplos incluem Linux, Windows NT/2000/XP/Vista/7/8/10.

Sistemas Virtuais

• Esta estrutura cria uma máquina virtual que simula uma arquitetura de hardware para cada processo.
• Cada processo tem a ilusão de que possui seu próprio sistema operacional.
• Exemplos incluem máquinas virtuais como VMware, VirtualBox e Hyper-V.

(a) Um hipervisor de tipo 1. (b) Um hipervisor de tipo 2 puro. (c) Um hipervisor de tipo 2 na prática.

Processos

• Um processo é apenas uma instância de um programa em execução, incluindo os valores atuais do contador do programa, registradores e variáveis.
• Processos podem ser criados e terminados dinamicamente.
• Cada processo tem seu próprio espaço de endereçamento.

O modelo de processo

1. Vemos um computador multiprogramando quatro programas na memória.
2. Vemos quatro processos, cada um com seu próprio fluxo de controle e sendo executado independente dos outros.
3. Vemos que, analisados durante um intervalo longo o suficiente, todos os processos tiveram progresso, mas a qualquer dado instante apenas um está sendo de fato executado.

Criação de processos

Sistemas operacionais precisam de alguma maneira para criar processos.

Quatro eventos principais fazem com que os processos sejam criados:

Criação de processos

child.sh

!/bin/bash
sleep infinity

parent.sh

!/bin/bash
./child.sh &
sleep infinity

$

parent.sh &

$

pgrep -P <parent pid>
pgrep -lP <parent pid>
pstree -p <parent pid>
ps --ppid <parent pid>
ls /proc/<parent pid>/task
cat /proc/<parent pid>/task/<parent pid>/children

Término de processos

Hierarquias de processos

$

./grandparent.sh
ps -efj | egrep "PGID|children|parent"
kill -9 -<pgid>

grandparent.sh

!/bin/bash
bash parent.sh &
bash parent.sh &
for i in {1..100}; do 
sleep 2; 
echo -n "This is the grandparent process $i"; 
done

parent.sh

!/bin/bash
bash children.sh &
bash children.sh &
for i in {1..100}; do sleep 2; echo -n "This is the parent process $i"; 
done

children.sh

!/bin/bash
for i in {1..100}; do 
sleep 2; 
echo -n "This is a test in children process $i"; 
done

Estados de processos

$

curl -s https://openbible.com/textfiles/kjv.txt | \
grep "Exodus\s2" | \
head -4

Estados de processos

Estados de processos

O nível mais baixo de um sistema operacional estruturado em processos controla interrupções e escalonamento. Acima desse nível estão processos sequenciais.

O escalonamento, isto é, decidir qual processo deve ser executado, quando e por quanto tempo, é um assunto importante; nós o examinaremos mais adiante neste capítulo. Muitos algoritmos foram desenvolvidos para tentar equilibrar as demandas concorrentes de eficiência para o sistema como um todo e justiça para os processos individuais.

Implementação de processos

Para implementar o modelo de processos, o sistema operacional mantém uma tabela (um arranjo de estruturas) chamada de tabela de processos, com uma entrada para cada um deles.

Threads

Cada processo tem um espaço de endereçamento e um único thread de controle. Na realidade, essa é quase a definição de um processo. Não obstante isso, em muitas situações, é desejável ter múltiplos threads de controle no mesmo espaço de endereçamento executando em quase paralelo, como se eles fossem (quase) processos separados (exceto pelo espaço de endereçamento compartilhado).

Threads, miniprocessos

Por que alguém iria querer ter um tipo de processo dentro de um processo? Na realidade, há várias razões para a existência desses miniprocessos, chamados threads

Um processador de texto com três threads

Um processador de texto com três threads

Deve ficar claro que ter três processos em separado não funcionaria aqui, pois todos os três threads precisam operar no documento. Ao existirem três threads em vez de três processos, eles compartilham de uma memória comum.

O modelo de thread clássico

Threads POSIX

Executando Threads

multiple_threads.py

"""
Executando Múltiplas Threads

https://realpython.com/intro-to-python-threading/
"""

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting, ID: %s", name, threading.get_native_id())
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

Convertendo de um thread para multithread

Conflitos entre threads sobre o uso de uma variável global